/*
 * Copyright (c) 2024 Shenzhen Kaihong Digital Industry Development Co., Ltd.
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 * http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
#include "station_controller.h"

#include <cstddef>
#include <string>
#include <unordered_map>

#include "cJSON.h"
#include "iot_connect_log.h"
#include "sle_bridge_errors.h"
#include "sle_thing_model_define.h"
#include "parameter.h"

namespace OHOS {
namespace iotConnect {
SleBaseDeviceInfo StationController::sleBaseDeviceInfo_ = {"skh", "000001", "123", PERR_CONNECT_TYPE_OFFLINE};
SleBaseWiFiInfo StationController::sleBaseWiFiInfo_ = {};
SleBaseSleInfo StationController::sleBaseSleInfo_ = {};
ConfigurationManagementInfo StationController::configurationManagementInfo_ = {};
SleBaseCPUInfo StationController::sleBaseCPUInfo_ = {};
SleBaseOSInfo StationController::sleBaseOSInfo_ = {};
SleBaseOTAInfo StationController::sleBaseOTAInfo_ = {};
SleBaseRestartInfo StationController::sleBaseRestartInfo_ = {};
SleBaseFactoryReset StationController::sleBaseFactoryReset_ = {};

#define JSON_STR_SNW "snw"

int32_t StationController::DevInfoGetCharState(const IotcCharState inData, char **data, uint32_t *len) const
{
    if (data == nullptr || *data != nullptr || len == nullptr) {
        IOTC_LOGE("param invalid");
        return -1;
    }

    cJSON *json = cJSON_CreateObject();
    if (json == nullptr) {
        HILOGE("create obj error");
        return SLE_BRIDGE_ERR_CREATE_JSON;
    }

    if (cJSON_AddStringToObject(json, "brand", GetBrand()) == nullptr) {
        cJSON_Delete(json);
        HILOGE("add brand error");
        return SLE_BRIDGE_ERR_ADD_JSON_DATA;
    }

    if (cJSON_AddStringToObject(json, "serialNumber", GetSerial()) == nullptr) {
        cJSON_Delete(json);
        HILOGE("add serialNumber error");
        return SLE_BRIDGE_ERR_ADD_JSON_DATA;
    }

    *data = cJSON_PrintUnformatted(json);
    *len = strlen(*data);

    return SLE_BRIDGE_SUCCESS;
}

int32_t StationController::ConfigurationManagementGetCharState(const IotcCharState inData, char **data, uint32_t *len)
{
    return SLE_BRIDGE_SUCCESS;
}

int32_t StationController::ConfigurationManagementPutCharState(const IotcCharState inData, const char *data, uint32_t len)
{
    return SLE_BRIDGE_SUCCESS;
}

extern IotcDeviceInfo DEV_INFO;

int32_t StationController::GetSn(char **data, uint32_t *len)
{
    if (data == NULL || *data != NULL) {
        IOTC_LOGE("param invalid");
        return -1;
    }

    cJSON *json = cJSON_CreateObject();
    if (json == NULL) {
        IOTC_LOGE("create obj error");
        return -1;
    }

    if (cJSON_AddStringToObject(json, JSON_STR_SNW, DEV_INFO.sn) == NULL) {
        cJSON_Delete(json);
        IOTC_LOGE("add num error");
        return -1;
    }

    *data = cJSON_PrintUnformatted(json);
    cJSON_Delete(json);
    if (*data == NULL) {
        IOTC_LOGE("json print error");
        return -1;
    }
    IOTC_LOGI("sn on get %s", DEV_INFO.sn);
    *len = strlen(*data);

    return SLE_BRIDGE_SUCCESS;
}

int32_t StationController::PutSn(const char *data, uint32_t len)
{
   if (data == NULL || len == 0) {
        IOTC_LOGE("param invalid");
        return -1;
    }
    cJSON *json = cJSON_Parse(data);
    if (json == NULL) {
        IOTC_LOGE("parse error");
        return -1;
    }

    cJSON *item = cJSON_GetObjectItem(json, JSON_STR_SNW);
    if (item == NULL) {
        cJSON_Delete(json);
        IOTC_LOGE("get on error");
        return -1;
    }
    IOTC_LOGI("sn on put =>%s", cJSON_GetStringValue(item));
    cJSON_Delete(json);

    return SLE_BRIDGE_SUCCESS;
}

int32_t StationController::InternalHandler(const IotcCharState inData, char **out, uint32_t *len, ThingModelPutOrGet flag)
{
    auto iter = mapThingModelSvcStation.find(std::string(inData.svcId));
    if(mapThingModelSvcStation.end() == iter) {
        HILOGE("not find svrId, svrId:%{public}s", inData.svcId);
        return SLE_BRIDGE_ERR_INVALID_PARAM;
    }

    SvcType type = static_cast<SvcType>(iter->second);
    switch (type)
    {
    case SvcType::DEV_INFO:
    {
        this->DevInfoGetCharState(inData, out, len);
        break;
    }
    case SvcType::CONFIGURATION_MAG:
    {
        if(ThingModelPutOrGet::GET == flag) {
            this->ConfigurationManagementGetCharState(inData, out, len);
        }else {
            this->ConfigurationManagementPutCharState(inData, nullptr, 0);
        }
        break;
    }
    case SvcType::GET_SN:
    {
        if(ThingModelPutOrGet::GET == flag) {
            this->GetSn(out, len);
        }else {
            this->PutSn(inData.data, *len);
        }
        break;
    }
    default:
    {
        HILOGE("not find svrId, svrId:%{public}s", inData.svcId);
        break;
    }
        
    }
    return SLE_BRIDGE_SUCCESS;
}

int32_t StationController::GetAllInfoHandler(const std::string& devId, IotcCharState *state)
{
    // uint8_t num = 0;
    // std::for_each(mapThingModelSvcStation.begin(), mapThingModelSvcStation.end(),
    //         [&state, &num, this](const std::tuple<std::string, SvcType>& value){
    //     state[num].svcId = std::get<0>(value).c_str();
      
    //     InternalHandler(state[num], state[num], ThingModelPutOrGet::GET);
    //     num++;
    // });

    return SLE_BRIDGE_SUCCESS;
}

// void PackDevInfoData(json);

// int32_t StationController::WifiInfoGetCharState(const IotcCharState& state, char **outData, uint32_t *outLen)
// {
//     // if (data == NULL || *data != NULL) {
//     //     HILOGE("param invalid");
//     //     return SLE_BRIDGE_ERR_INVALID_PARAM;
//     // }

//     // cJSON *json = cJSON_CreateObject();
//     // if (json == NULL) {
//     //     HILOGE("create obj error");
//     //     return SLE_BRIDGE_ERR_CREATE_JSON;
//     // }

//     // if (cJSON_AddStringToObject(json, "wifiMac", sleBaseWiFiInfo_.wifiMac.c_str()) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add string error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // if (cJSON_AddStringToObject(json, "ipv4Addr", sleBaseWiFiInfo_.ipv4Addr.c_str()) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add string error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // if (cJSON_AddNumberToObject(json, "RSSI", sleBaseWiFiInfo_.RSSI) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add num error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // if (cJSON_AddStringToObject(json, "SSID", sleBaseWiFiInfo_.SSID.c_str()) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add string error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // *data = cJSON_PrintUnformatted(json);
//     // cJSON_Delete(json);
//     // if (*data == NULL) {
//     //     HILOGE("json print error");
//     //     return SLE_BRIDGE_ERR_PRINT_JSON;
//     // }
//     // *len = strlen(*data);

//     // IotcCharState reportInfo;
//     // reportInfo.svcId = svc->svcId;
//     // reportInfo.len = *len;
//     // reportInfo.data = *data;
//     // int ret = IotcOhDevReportCharState(&reportInfo, 1);
//     // if (ret != 0) {
//     //     HILOGE("IotcOhDevReportCharState error");
//     //     return SLE_BRIDGE_FAILED;
//     // }

//     return SLE_BRIDGE_SUCCESS;
// }

// int32_t StationController::SleInfoGetCharState(char **data, uint32_t *len)
// {
//     // if (data == NULL || *data != NULL) {
//     //     HILOGE("param invalid");
//     //     return SLE_BRIDGE_ERR_INVALID_PARAM;
//     // }

//     // cJSON *json = cJSON_CreateObject();
//     // if (json == NULL) {
//     //     HILOGE("create obj error");
//     //     return SLE_BRIDGE_ERR_CREATE_JSON;
//     // }

//     // if (cJSON_AddStringToObject(json, "sleMac", sleBaseSleInfo_.sleMac.c_str()) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add string error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // if (cJSON_AddNumberToObject(json, "RSSI", sleBaseSleInfo_.RSSI) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add num error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // *data = cJSON_PrintUnformatted(json);
//     // cJSON_Delete(json);
//     // if (*data == NULL) {
//     //     HILOGE("json print error");
//     //     return SLE_BRIDGE_ERR_PRINT_JSON;
//     // }
//     // *len = strlen(*data);

//     // IotcCharState reportInfo;
//     // reportInfo.svcId = svc->svcId;
//     // reportInfo.len = *len;
//     // reportInfo.data = *data;
//     // int ret = IotcOhDevReportCharState(&reportInfo, 1);
//     // if (ret != 0) {
//     //     HILOGE("IotcOhDevReportCharState error");
//     //     return SLE_BRIDGE_FAILED;
//     // }

//     return SLE_BRIDGE_SUCCESS;
// }

// int32_t StationController::ConfigurationManagementGetCharState(const IotcCharState& state, char **outData, uint32_t *outLen)
// {
//     // if (data == NULL || *data != NULL) {
//     //     HILOGE("param invalid");
//     //     return SLE_BRIDGE_ERR_INVALID_PARAM;
//     // }

//     // cJSON *json = cJSON_CreateObject();
//     // if (json == NULL) {
//     //     HILOGE("create obj error");
//     //     return SLE_BRIDGE_ERR_CREATE_JSON;
//     // }

//     // if (cJSON_AddNumberToObject(json, "discoveryType", configurationManagementInfo_.discoveryType) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add num error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // if (cJSON_AddNumberToObject(json, "accessType", configurationManagementInfo_.accessType) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add num error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // if (cJSON_AddStringToObject(json, "deviceName", configurationManagementInfo_.deviceName.c_str()) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add string error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // *data = cJSON_PrintUnformatted(json);
//     // cJSON_Delete(json);
//     // if (*data == NULL) {
//     //     HILOGE("json print error");
//     //     return SLE_BRIDGE_ERR_PRINT_JSON;
//     // }
//     // *len = strlen(*data);

//     // IotcCharState reportInfo;
//     // reportInfo.svcId = svc->svcId;
//     // reportInfo.len = *len;
//     // reportInfo.data = *data;
//     // int ret = IotcOhDevReportCharState(&reportInfo, 1);
//     // if (ret != 0) {
//     //     HILOGE("IotcOhDevReportCharState error");
//     //     return SLE_BRIDGE_FAILED;
//     // }

//     return SLE_BRIDGE_SUCCESS;
// }

// int32_t StationController::ConfigurationManagementPutCharState(const IotcCharState& state, char **outData, uint32_t *outLen)
// {
//     // if (data == NULL || len == 0) {
//     //     return SLE_BRIDGE_ERR_INVALID_PARAM;
//     // }
//     // cJSON *json = cJSON_Parse(data);
//     // if (json == NULL) {
//     //     HILOGE("Parse json error");
//     //     return SLE_BRIDGE_ERR_PARSE_JSON;
//     // }

//     // cJSON *item = cJSON_GetObjectItem(json, "deviceName");
//     // if (item == NULL || !cJSON_IsString(item)) {
//     //     cJSON_Delete(json);
//     //     return SLE_BRIDGE_FAILED;
//     // }
//     // configurationManagementInfo_.deviceName = cJSON_GetStringValue(item);

//     // cJSON_Delete(json);
//     return SLE_BRIDGE_SUCCESS;
// }

// int32_t StationController::CPUInfoGetCharState(char **data, uint32_t *len)
// {
//     // if (data == NULL || *data != NULL) {
//     //     HILOGE("param invalid");
//     //     return SLE_BRIDGE_ERR_INVALID_PARAM;
//     // }

//     // cJSON *json = cJSON_CreateObject();
//     // if (json == NULL) {
//     //     HILOGE("create obj error");
//     //     return SLE_BRIDGE_ERR_CREATE_JSON;
//     // }

//     // if (cJSON_AddStringToObject(json, "manufacturer", sleBaseCPUInfo_.manufacturer.c_str()) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add string error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // if (cJSON_AddStringToObject(json, "model", sleBaseCPUInfo_.model.c_str()) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add string error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // if (cJSON_AddNumberToObject(json, "currentUsage", sleBaseCPUInfo_.currentUsage) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add num error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // if (cJSON_AddNumberToObject(json, "usageThreshold", sleBaseCPUInfo_.usageThreshold) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add num error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // *data = cJSON_PrintUnformatted(json);
//     // cJSON_Delete(json);
//     // if (*data == NULL) {
//     //     HILOGE("json print error");
//     //     return SLE_BRIDGE_ERR_PRINT_JSON;
//     // }
//     // *len = strlen(*data);

//     // IotcCharState reportInfo;
//     // reportInfo.svcId = svc->svcId;
//     // reportInfo.len = *len;
//     // reportInfo.data = *data;
//     // int ret = IotcOhDevReportCharState(&reportInfo, 1);
//     // if (ret != 0) {
//     //     HILOGE("IotcOhDevReportCharState error");
//     //     return SLE_BRIDGE_FAILED;
//     // }

//     return SLE_BRIDGE_SUCCESS;
// }

// int32_t StationController::OSInfoGetCharState(const IotcCharState& state, char **outData, uint32_t *outLen)
// {
//     // if (data == NULL || *data != NULL) {
//     //     HILOGE("param invalid");
//     //     return SLE_BRIDGE_ERR_INVALID_PARAM;
//     // }

//     // cJSON *json = cJSON_CreateObject();
//     // if (json == NULL) {
//     //     HILOGE("create obj error");
//     //     return SLE_BRIDGE_ERR_CREATE_JSON;
//     // }

//     // if (cJSON_AddStringToObject(json, "version", sleBaseOSInfo_.version.c_str()) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add string error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // if (cJSON_AddNumberToObject(json, "type", sleBaseOSInfo_.type) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add num error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // *data = cJSON_PrintUnformatted(json);
//     // cJSON_Delete(json);
//     // if (*data == NULL) {
//     //     HILOGE("json print error");
//     //     return SLE_BRIDGE_ERR_PRINT_JSON;
//     // }
//     // *len = strlen(*data);

//     // IotcCharState reportInfo;
//     // reportInfo.svcId = svc->svcId;
//     // reportInfo.len = *len;
//     // reportInfo.data = *data;
//     // int ret = IotcOhDevReportCharState(&reportInfo, 1);
//     // if (ret != 0) {
//     //     HILOGE("IotcOhDevReportCharState error");
//     //     return SLE_BRIDGE_FAILED;
//     // }

//     return SLE_BRIDGE_SUCCESS;
// }

// int32_t StationController::OTAInfoGetCharState(char **data, uint32_t *len)
// {
//     // if (data == NULL || *data != NULL) {
//     //     HILOGE("param invalid");
//     //     return SLE_BRIDGE_ERR_INVALID_PARAM;
//     // }

//     // cJSON *json = cJSON_CreateObject();
//     // if (json == NULL) {
//     //     HILOGE("create obj error");
//     //     return SLE_BRIDGE_ERR_CREATE_JSON;
//     // }

//     // if (cJSON_AddNumberToObject(json, "action", sleBaseOTAInfo_.action) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add num error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // if (cJSON_AddNumberToObject(json, "bootTime", sleBaseOTAInfo_.bootTime) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add num error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // if (cJSON_AddStringToObject(json, "introduction", sleBaseOTAInfo_.introduction.c_str()) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add string error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // if (cJSON_AddNumberToObject(json, "progress", sleBaseOTAInfo_.progress) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add num error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // if (cJSON_AddStringToObject(json, "version", sleBaseOTAInfo_.version.c_str()) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add string error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // if (cJSON_AddStringToObject(json, "url", sleBaseOTAInfo_.url.c_str()) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add string error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // if (cJSON_AddBoolToObject(json, "on", sleBaseOTAInfo_.on) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add bool error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // if (cJSON_AddNumberToObject(json, "code", sleBaseOTAInfo_.code) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add num error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // *data = cJSON_PrintUnformatted(json);
//     // cJSON_Delete(json);
//     // if (*data == NULL) {
//     //     HILOGE("json print error");
//     //     return SLE_BRIDGE_ERR_PRINT_JSON;
//     // }
//     // *len = strlen(*data);

//     // IotcCharState reportInfo;
//     // reportInfo.svcId = svc->svcId;
//     // reportInfo.len = *len;
//     // reportInfo.data = *data;
//     // int ret = IotcOhDevReportCharState(&reportInfo, 1);
//     // if (ret != 0) {
//     //     HILOGE("IotcOhDevReportCharState error");
//     //     return SLE_BRIDGE_FAILED;
//     // }

//     return SLE_BRIDGE_SUCCESS;
// }

// int32_t StationController::OTAInfoPutCharState(const IotcCharState& state, char **outData, uint32_t *outLen)
// {
//     // if (data == NULL || len == 0) {
//     //     return SLE_BRIDGE_ERR_INVALID_PARAM;
//     // }
//     // cJSON *json = cJSON_Parse(data);
//     // if (json == NULL) {
//     //     HILOGE("Parse json error");
//     //     return SLE_BRIDGE_ERR_PARSE_JSON;
//     // }

//     // cJSON *item = cJSON_GetObjectItem(json, "on");
//     // if (item == NULL || !cJSON_IsBool(item)) {
//     //     cJSON_Delete(json);
//     //     return SLE_BRIDGE_ERR_GET_JSON_DATA;
//     // }

//     // if (item->type == cJSON_True) {
//     //     // TODO: 需要添加具体业务
//     //     sleBaseOTAInfo_.on = true;
//     // } else {
//     //     // TODO: 需要添加具体业务
//     //     sleBaseOTAInfo_.on = false;
//     // }
//     // cJSON_Delete(json);
//     return SLE_BRIDGE_SUCCESS;
// }

// int32_t StationController::RestartInfoGetCharState(const IotcCharState& state, char **outData, uint32_t *outLen)
// {
//     // if (data == NULL || *data != NULL) {
//     //     HILOGE("param invalid");
//     //     return SLE_BRIDGE_ERR_INVALID_PARAM;
//     // }

//     // cJSON *json = cJSON_CreateObject();
//     // if (json == NULL) {
//     //     HILOGE("create obj error");
//     //     return SLE_BRIDGE_ERR_CREATE_JSON;
//     // }

//     // if (cJSON_AddBoolToObject(json, "restart", sleBaseRestartInfo_.restart) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add bool error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // *data = cJSON_PrintUnformatted(json);
//     // cJSON_Delete(json);
//     // if (*data == NULL) {
//     //     HILOGE("json print error");
//     //     return SLE_BRIDGE_ERR_PRINT_JSON;
//     // }
//     // *len = strlen(*data);

//     // IotcCharState reportInfo;
//     // reportInfo.svcId = svc->svcId;
//     // reportInfo.len = *len;
//     // reportInfo.data = *data;
//     // int ret = IotcOhDevReportCharState(&reportInfo, 1);
//     // if (ret != 0) {
//     //     HILOGE("IotcOhDevReportCharState error");
//     //     return SLE_BRIDGE_FAILED;
//     // }

//     return SLE_BRIDGE_SUCCESS;
// }

// int32_t StationController::RestartInfoPutCharState(const IotcCharState& state, char **outData, uint32_t *outLen)
// {
//     // if (data == NULL || len == 0) {
//     //     return SLE_BRIDGE_ERR_INVALID_PARAM;
//     // }
//     // cJSON *json = cJSON_Parse(data);
//     // if (json == NULL) {
//     //     HILOGE("Parse json error");
//     //     return SLE_BRIDGE_ERR_PARSE_JSON;
//     // }

//     // cJSON *item = cJSON_GetObjectItem(json, "restart");
//     // if (item == NULL || !cJSON_IsBool(item)) {
//     //     cJSON_Delete(json);
//     //     return SLE_BRIDGE_ERR_GET_JSON_DATA;
//     // }

//     // if (item->type == cJSON_True) {
//     //     // TODO: 需要添加具体业务
//     //     sleBaseRestartInfo_.restart = true;
//     // } else {
//     //     // TODO: 需要添加具体业务
//     //     sleBaseRestartInfo_.restart = false;
//     // }
//     // cJSON_Delete(json);

//     return SLE_BRIDGE_SUCCESS;
// }

// int32_t StationController::FactoryResetGetCharState(const IotcCharState& state, char **outData, uint32_t *outLen)
// {
//     // if (data == NULL || *data != NULL) {
//     //     HILOGE("param invalid");
//     //     return SLE_BRIDGE_ERR_INVALID_PARAM;
//     // }

//     // cJSON *json = cJSON_CreateObject();
//     // if (json == NULL) {
//     //     HILOGE("create obj error");
//     //     return SLE_BRIDGE_ERR_CREATE_JSON;
//     // }

//     // if (cJSON_AddBoolToObject(json, "factoryReset", sleBaseFactoryReset_.resetAllSettings) == NULL) {
//     //     cJSON_Delete(json);
//     //     HILOGE("add bool error");
//     //     return SLE_BRIDGE_ERR_ADD_JSON_DATA;
//     // }

//     // *data = cJSON_PrintUnformatted(json);
//     // cJSON_Delete(json);
//     // if (*data == NULL) {
//     //     HILOGE("json print error");
//     //     return SLE_BRIDGE_ERR_PRINT_JSON;
//     // }
//     // *len = strlen(*data);

//     // IotcCharState reportInfo;
//     // reportInfo.svcId = svc->svcId;
//     // reportInfo.len = *len;
//     // reportInfo.data = *data;
//     // int ret = IotcOhDevReportCharState(&reportInfo, 1);
//     // if (ret != 0) {
//     //     HILOGE("IotcOhDevReportCharState error");
//     //     return SLE_BRIDGE_FAILED;
//     // }

//     return SLE_BRIDGE_SUCCESS;
// }

// int32_t StationController::FactoryResetPutCharState(const IotcCharState& state, char **outData, uint32_t *outLen)
// {
//     // if (data == NULL || len == 0) {
//     //     return SLE_BRIDGE_ERR_INVALID_PARAM;
//     // }
//     // cJSON *json = cJSON_Parse(data);
//     // if (json == NULL) {
//     //     HILOGE("Parse json error");
//     //     return SLE_BRIDGE_ERR_PARSE_JSON;
//     // }

//     // cJSON *item = cJSON_GetObjectItem(json, "resetAllSettings");
//     // if (item == NULL || !cJSON_IsBool(item)) {
//     //     cJSON_Delete(json);
//     //     return SLE_BRIDGE_ERR_GET_JSON_DATA;
//     // }

//     // if (item->type == cJSON_True) {
//     //     // TODO: 需要添加具体业务
//     //     sleBaseFactoryReset_.resetAllSettings = true;
//     // } else {
//     //     // TODO: 需要添加具体业务
//     //     sleBaseFactoryReset_.resetAllSettings = false;
//     // }
//     // cJSON_Delete(json);
//     return SLE_BRIDGE_SUCCESS;
// }

int32_t StationController::GetSleBaseDeviceInfo(SleBaseDeviceInfo& devInfo)
{
    devInfo = sleBaseDeviceInfo_;
    return SLE_BRIDGE_SUCCESS;
}
}
}
